﻿#include <iostream>

template <class T>
class shared_ptr 
{
public:
	T& operator*() const
	{		return *px;	}

	T* operator->() const
	{		return px;	}

	shared_ptr(T* p = NULL) : px(p) {}
	~shared_ptr() {
		if (px)
		{
			delete px;
		}
	}
private:
	T*	px;
	long*	pn;
};

struct Foo
{
	Foo() { std::cout << __FUNCTION__ << std::endl; }
	~Foo() { std::cout << __FUNCTION__ << std::endl; }
	void method(void) { std::cout << __FUNCTION__ << std::endl; }
};

template <class T>
struct __list_node {
	void* prev;
	void* next;
	T data;
};

template <class T, class Ref, class Ptr>
struct __list_interator{
	typedef __list_interator<T, Ref, Ptr> self;
	typedef Ptr pointer;
	typedef Ref reference;
	typedef __list_node<T>* link_type;
	link_type node;//迭代器的指针，所指向的容器成员
	bool operator ==(const self& x) const { return node == x.node; }
	bool operator != (const self& x) const { return node != x.node; }
	reference operator*()const { return (*node).data; }
	pointer operator->() const { return &(operator*()); }
	self& operator++() { node = (link_type)((*node).next); return *this; }
	self& operator--() { node = (link_type)(*node).prev; return *this; }//node 是指向容器成员的指针，(*node)就是对象本身，通过next获取到下一个元素，而next 返回的void*,所以要强转为 link_type。 再赋值给 node，就实现了 迭代器指向元素的偏移。为什么不是node->next？
};
int main(void)
{
	shared_ptr<Foo> sp(new Foo);
	/*
		shared_ptr<Foo> 类型
		sp 变量名
		new Foo 参数， `new Foo` 会返回一个指针
	*/

	
}